import { extension_settings, getContext } from '/scripts/extensions.js';
import { 
    saveSettingsDebounced,
    eventSource,
    event_types,
    saveChatConditional,
    reloadCurrentChat
} from '/script.js';
import { SlashCommandParser } from '/scripts/slash-commands/SlashCommandParser.js';
import { SlashCommand } from '/scripts/slash-commands/SlashCommand.js';

// 插件名称
const extensionName = 'chat-reply-checker';
const extensionFolderPath = `scripts/extensions/third-party/sillytavern-chat-reply-checker`;

// 默认设置
const defaultSettings = {
    enabled: true,
    apiUrl: 'http://localhost:5001/v1',
    apiKey: '', // Python服务不需要API Key（可以留空）
    model: 'deepseek-r1-250528',
    maxTokens: 12000,
    temperature: 1.2,
    contextMessages: 2, // 上下文消息数量
    systemPrompt: ''
};

// 加载设置
async function loadSettings() {
    if (!extension_settings[extensionName]) {
        extension_settings[extensionName] = {};
    }

    // 合并默认设置
    extension_settings[extensionName] = {
        ...defaultSettings,
        ...extension_settings[extensionName]
    };

    // 更新UI
    updateUI();
}

// 保存设置
function saveSettings() {
    saveSettingsDebounced();
}

// 更新UI
function updateUI() {
    const settings = extension_settings[extensionName];
    
    $('#chat_reply_checker_enabled').prop('checked', settings.enabled);
    $('#chat_reply_checker_api_url').val(settings.apiUrl);
    $('#chat_reply_checker_api_key').val(settings.apiKey);
    $('#chat_reply_checker_model').val(settings.model);
    $('#chat_reply_checker_max_tokens').val(settings.maxTokens);
    $('#chat_reply_checker_max_tokens_value').text(settings.maxTokens);
    $('#chat_reply_checker_temperature').val(settings.temperature);
    $('#chat_reply_checker_temperature_value').text(settings.temperature);
    $('#chat_reply_checker_context_messages').val(settings.contextMessages);
    $('#chat_reply_checker_context_messages_value').text(settings.contextMessages);
    console.log('[聊天回复检查器] UI已更新，当前上下文消息数量:', settings.contextMessages);
    $('#chat_reply_checker_system_prompt').val(settings.systemPrompt);
}

// 本地检查已移除，完全依赖API进行智能检查

// 本地检查功能已移除，完全依赖API智能检查

// 检查最新消息（简化版本，仅做基础验证）
async function checkLatestMessage() {
    const context = getContext();
    const chat = context.chat;
    
    if (!chat || chat.length === 0) {
        console.log('[聊天回复检查器] 没有聊天记录');
        return { message: null, previousMessages: [] };
    }
    
    const latestMessage = chat[chat.length - 1];
    
    console.log('[聊天回复检查器] 检查消息:', {
        isUser: latestMessage.is_user,
        messageLength: latestMessage.mes?.length,
        messagePreview: latestMessage.mes?.substring(0, 50) + '...'
    });
    
    // 只检查AI的回复
    if (latestMessage.is_user) {
        console.log('[聊天回复检查器] 跳过用户消息');
        return { message: latestMessage, previousMessages: [] };
    }
    
    // 获取上下文消息（根据用户设置）
    const settings = extension_settings[extensionName];
    const contextCount = settings.contextMessages || 2;
    const startIndex = Math.max(0, chat.length - 1 - contextCount);
    const previousMessages = chat.slice(startIndex, chat.length - 1);
    
    console.log('[聊天回复检查器] 上下文设置:', {
        contextMessages: settings.contextMessages,
        contextCount: contextCount,
        chatLength: chat.length,
        startIndex: startIndex,
        previousMessagesCount: previousMessages.length
    });
    
    console.log('[聊天回复检查器] 获取上下文消息:', {
        previousMessages: previousMessages.length,
        startIndex: startIndex
    });
    
    return { message: latestMessage, previousMessages };
}

// 使用API检查和修复消息
async function checkAndFixWithAPI(latestMessage, previousMessages, isRetry = false) {
    const settings = extension_settings[extensionName];
    
    if (!settings.apiUrl) {
        console.error('[聊天回复检查器] 未配置API URL');
        return null;
    }
    
    // 构建检查内容（简化版本）
    let checkContent = `请检查并优化以下文本：\n\n"${latestMessage.mes}"\n\n`;
    
    // 始终提供上下文参考（让AI自主判断是否需要考虑）
    if (previousMessages.length > 0) {
        checkContent += '上下文参考：\n';
        const recentMessages = previousMessages.slice(-2);
        recentMessages.forEach((msg, index) => {
            const speaker = msg.is_user ? '用户' : 'AI';
            checkContent += `${speaker}: "${msg.mes}"\n`;
        });
        checkContent += '\n';
    }
    
    checkContent += '请按照系统提示的格式分析并回复。';
    
    // 构建请求消息
    const messages = [
        {
            role: 'system',
            content: settings.systemPrompt
        },
        {
            role: 'user',
            content: checkContent
        }
    ];
    
    try {
        // 确保URL格式正确
        let apiUrl = settings.apiUrl;
        if (!apiUrl.endsWith('/chat/completions')) {
            // 处理不同的API端点格式
            if (apiUrl.includes('ark.cn-beijing.volces.com')) {
                // 火山引擎 ARK API
                if (!apiUrl.endsWith('/chat/completions')) {
                    apiUrl = apiUrl + '/chat/completions';
                }
            } else {
                // 标准 OpenAI 格式
                if (apiUrl.endsWith('/v1')) {
                    apiUrl = apiUrl + '/chat/completions';
                } else if (apiUrl.endsWith('/')) {
                    apiUrl = apiUrl + 'v1/chat/completions';
                } else {
                    apiUrl = apiUrl + '/v1/chat/completions';
                }
            }
        }
        
        const requestBody = {
            model: settings.model,
            messages: messages,
            max_tokens: settings.maxTokens,
            temperature: settings.temperature,
            stream: false
        };
        
        console.log('[聊天回复检查器] API请求:', {
            url: apiUrl,
            model: settings.model,
            messagesCount: messages.length,
            isRetry: isRetry
        });
        
        console.log('[聊天回复检查器] 发送的消息内容:', messages);
        
        // 详细显示发送给AI的内容
        console.log('='.repeat(50));
        console.log('发送给AI的完整内容：');
        console.log('='.repeat(50));
        messages.forEach((msg, index) => {
            console.log(`消息 ${index + 1} (${msg.role}):`);
            console.log(msg.content);
            console.log('-'.repeat(30));
        });
        console.log('='.repeat(50));
        
        const headers = {
            'Content-Type': 'application/json'
        };
        
        // 只有在有API Key时才添加Authorization头
        if (settings.apiKey) {
            headers['Authorization'] = `Bearer ${settings.apiKey}`;
        }
        
        const response = await fetch(apiUrl, {
            method: 'POST',
            headers: headers,
            body: JSON.stringify(requestBody)
        });
        
        if (!response.ok) {
            const errorText = await response.text();
            console.error('[聊天回复检查器] API请求失败详情:', {
                status: response.status,
                statusText: response.statusText,
                headers: Object.fromEntries(response.headers.entries()),
                errorBody: errorText
            });
            console.log('='.repeat(50));
            console.log('API错误响应内容：');
            console.log(errorText);
            console.log('='.repeat(50));
            throw new Error(`API请求失败: ${response.status} ${response.statusText} - ${errorText}`);
        }
        
        const data = await response.json();
        console.log('[聊天回复检查器] API响应:', data);
        
        // 详细分析API响应结构
        console.log('='.repeat(50));
        console.log('API响应详细分析：');
        console.log('响应状态:', response.status, response.statusText);
        console.log('响应头:', Object.fromEntries(response.headers.entries()));
        console.log('响应数据结构:');
        console.log('- id:', data.id);
        console.log('- object:', data.object);
        console.log('- created:', data.created);
        console.log('- model:', data.model);
        console.log('- choices数量:', data.choices?.length);
        if (data.choices && data.choices.length > 0) {
            console.log('- 第一个choice:', data.choices[0]);
            console.log('- finish_reason:', data.choices[0]?.finish_reason);
            console.log('- message role:', data.choices[0]?.message?.role);
        }
        console.log('- usage:', data.usage);
        console.log('- error:', data.error);
        console.log('='.repeat(50));
        
        const apiResponse = data.choices?.[0]?.message?.content;
        
        if (!apiResponse) {
            console.error('[聊天回复检查器] API响应格式错误:', data);
            throw new Error('API返回的消息为空');
        }
        
        console.log('[聊天回复检查器] API返回内容:', apiResponse);
        console.log('='.repeat(50));
        console.log('API完整响应内容：');
        console.log(apiResponse);
        console.log('='.repeat(50));
        
        // 检查API是否返回错误信息
        if (apiResponse.includes('无法生成回复') || 
            apiResponse.includes('请尝试修改') ||
            apiResponse.includes('内容过滤') ||
            apiResponse.includes('违反政策')) {
            console.log('[聊天回复检查器] API返回错误信息，准备重试:', apiResponse);
            
            // 如果是第一次调用（没有重试标记），则进行重试
            if (!isRetry) {
                console.log('[聊天回复检查器] 开始重试API调用...');
                toastr.info('API返回错误，正在重试...', '聊天回复检查器');
                await new Promise(resolve => setTimeout(resolve, 1000)); // 等待1秒
                return await checkAndFixWithAPI(latestMessage, previousMessages, true); // 标记为重试
            } else {
                console.log('[聊天回复检查器] 重试后仍然失败，跳过检查');
                toastr.warning('API重试后仍然失败', '聊天回复检查器');
                return null;
            }
        }
        
        // 检查是否包含标签格式
        const hasThinkTag = apiResponse.includes('<think>');
        const hasContentTag = apiResponse.includes('<content>');
        
        if (hasThinkTag && hasContentTag) {
            // 如果有标签格式，解析内容
            const thinkMatch = apiResponse.match(/<think>([\s\S]*?)<\/think>/);
            const contentMatch = apiResponse.match(/<content>([\s\S]*?)<\/content>/);
            
            if (!thinkMatch) {
                console.log('[聊天回复检查器] API响应格式错误，未找到<think>标签');
                console.log('[聊天回复检查器] 原始响应:', apiResponse);
                return null;
            }
            
            const thinkContent = thinkMatch[1].trim();
            const fixedContent = contentMatch ? contentMatch[1].trim() : '';
            
            console.log('[聊天回复检查器] 分析结果:', thinkContent);
            console.log('[聊天回复检查器] 修复内容:', fixedContent);
            
            // 在界面显示分析结果
            if (thinkContent) {
                toastr.info(`AI分析: ${thinkContent.substring(0, 100)}${thinkContent.length > 100 ? '...' : ''}`, '聊天回复检查器', {timeOut: 5000});
            }
            
            // 如果修复内容为空，则不需要修复
            if (!fixedContent) {
                console.log('[聊天回复检查器] API判定：不需要优化');
                return null;
            }
            
            console.log('[聊天回复检查器] API判定：需要优化');
            // 返回完整的API响应，包含标签
            return apiResponse;
        } else {
            // 如果没有标签格式，直接处理为普通文本
            console.log('[聊天回复检查器] API返回普通文本格式');
            
            // 如果返回"无需改进"类似内容，则不修复
            if (apiResponse.includes('无需改进') || 
                apiResponse.includes('不需要改进') ||
                apiResponse.includes('质量良好') ||
                apiResponse.includes('没有问题')) {
                console.log('[聊天回复检查器] API判定：不需要优化');
                return null;
            }
            
            console.log('[聊天回复检查器] API判定：需要优化');
            return apiResponse;
        }
    } catch (error) {
        console.error('[聊天回复检查器] API调用出错:', error);
        console.log('='.repeat(50));
        console.log('完整错误信息：');
        console.log('错误类型:', error.name);
        console.log('错误消息:', error.message);
        console.log('错误堆栈:', error.stack);
        console.log('='.repeat(50));
        
        // 在界面显示错误信息
        toastr.error(`API调用失败: ${error.message}`, '聊天回复检查器', {timeOut: 8000});
        
        return null;
    }
}

// 存储已处理的消息，防止循环修复
const processedMessages = new Set();

// 处理消息接收事件（在渲染前拦截）
async function onMessageReceived(data) {
    console.log('[聊天回复检查器] 消息接收事件触发:', { data, eventType: 'onMessageReceived' });
    
    const settings = extension_settings[extensionName];
    
    console.log('[聊天回复检查器] 当前设置:', {
        enabled: settings.enabled,
        hasApiUrl: !!settings.apiUrl,
        apiUrl: settings.apiUrl
    });
    
    if (!settings.enabled) {
        console.log('[聊天回复检查器] 插件未启用，跳过检查');
        return;
    }
    
    if (!settings.apiUrl) {
        console.log('[聊天回复检查器] 未配置API URL，跳过检查');
        return;
    }
    
    const context = getContext();
    const chat = context.chat;
    
    if (!chat || chat.length === 0) {
        console.log('[聊天回复检查器] 没有聊天记录');
        return;
    }
    
    const latestMessage = chat[chat.length - 1];
    
    // 只处理AI的回复
    if (latestMessage.is_user) {
        console.log('[聊天回复检查器] 跳过用户消息');
        return;
    }
    
    // 跳过第一条消息（通常是系统消息或角色介绍）
    if (chat.length <= 1) {
        console.log('[聊天回复检查器] 跳过第一条消息');
        return;
    }
    
    // 跳过过短的消息（可能是系统消息）
    if (latestMessage.mes.length < 10) {
        console.log('[聊天回复检查器] 跳过过短的消息');
        return;
    }
    
    // 防循环检查：为消息生成唯一标识
    const messageKey = `${chat.length}-${latestMessage.mes.substring(0, 50)}`;
    
    if (processedMessages.has(messageKey)) {
        console.log('[聊天回复检查器] 消息已处理过，跳过检查避免循环');
        return;
    }
    
    // 标记消息为已处理
    processedMessages.add(messageKey);
    
    // 清理过期的标记（保留最近10条）
    if (processedMessages.size > 10) {
        const entries = Array.from(processedMessages);
        processedMessages.clear();
        entries.slice(-10).forEach(id => processedMessages.add(id));
    }
    
    // 获取上下文消息
    const contextCount = settings.contextMessages || 2;
    const startIndex = Math.max(0, chat.length - 1 - contextCount);
    const previousMessages = chat.slice(startIndex, chat.length - 1);
    
    console.log('[聊天回复检查器] onMessageReceived上下文设置:', {
        contextMessages: settings.contextMessages,
        contextCount: contextCount,
        chatLength: chat.length,
        startIndex: startIndex,
        previousMessagesCount: previousMessages.length
    });
    
    console.log('[聊天回复检查器] 开始检查生成的回复...');
    
    // 使用API检查和修复
    const fixedMessage = await checkAndFixWithAPI(latestMessage, previousMessages);
    
    if (fixedMessage && fixedMessage !== latestMessage.mes) {
        console.log('[聊天回复检查器] 内容已优化，显示优化版本');
        
        // 直接修改消息内容，不需要重新加载
        latestMessage.mes = fixedMessage;
        
        console.log('[聊天回复检查器] 回复已在显示前优化');
    } else {
        console.log('[聊天回复检查器] 内容无需优化，正常显示');
    }
}

// 手动检查命令（使用API检查）
async function checkCommand() {
    const settings = extension_settings[extensionName];
    if (!settings.apiUrl) {
        toastr.error('请先配置API URL', '聊天回复检查器');
        return '';
    }
    
    const checkResult = await checkLatestMessage();
    
    if (!checkResult.message) {
        toastr.info('没有可检查的消息', '聊天回复检查器');
        return '';
    }
    
    if (checkResult.message.is_user) {
        toastr.info('最新消息是用户消息，无需检查', '聊天回复检查器');
        return '';
    }
    
    toastr.info('正在使用API检查回复...', '聊天回复检查器');
    
    const fixedMessage = await checkAndFixWithAPI(checkResult.message, checkResult.previousMessages);
    
    if (fixedMessage && fixedMessage !== checkResult.message.mes) {
        toastr.warning('检测到问题，建议使用修复功能', '聊天回复检查器');
    } else {
        toastr.success('未检测到问题', '聊天回复检查器');
    }
    
    return '';
}

// 手动修复命令
async function fixCommand() {
    const settings = extension_settings[extensionName];
    if (!settings.apiUrl) {
        toastr.error('请先配置API URL', '聊天回复检查器');
        return '';
    }
    
    const context = getContext();
    const chat = context.chat;
    
    if (!chat || chat.length === 0) {
        toastr.info('没有可修复的消息', '聊天回复检查器');
        return '';
    }
    
    const latestMessage = chat[chat.length - 1];
    
    if (latestMessage.is_user) {
        toastr.info('最新消息是用户消息，无需修复', '聊天回复检查器');
        return '';
    }
    
    // 获取上下文消息
    const contextCount = settings.contextMessages || 2;
    const startIndex = Math.max(0, chat.length - 1 - contextCount);
    const previousMessages = chat.slice(startIndex, chat.length - 1);
    
    console.log('[聊天回复检查器] fixCommand上下文设置:', {
        contextMessages: settings.contextMessages,
        contextCount: contextCount,
        chatLength: chat.length,
        startIndex: startIndex,
        previousMessagesCount: previousMessages.length
    });
    
    toastr.info('正在检查并修复回复...', '聊天回复检查器');
    
    const fixedMessage = await checkAndFixWithAPI(latestMessage, previousMessages);
    
    if (fixedMessage && fixedMessage !== latestMessage.mes) {
        latestMessage.mes = fixedMessage;
        await saveChatConditional();
        await reloadCurrentChat();
        toastr.success('回复已修复', '聊天回复检查器');
    } else {
        toastr.info('未检测到需要修复的问题', '聊天回复检查器');
    }
    
    return '';
}

// 测试命令（使用API测试）
async function testReplyChecker() {
    const settings = extension_settings[extensionName];
    if (!settings.apiUrl) {
        toastr.error('请先配置API URL', '聊天回复检查器');
        return '';
    }
    
    const context = getContext();
    const chat = context.chat;
    
    if (!chat || chat.length < 2) {
        toastr.warning('需要至少2条消息才能测试', '聊天回复检查器');
        return '';
    }
    
    // 获取倒数第二条AI消息
    let testMessage = null;
    for (let i = chat.length - 2; i >= 0; i--) {
        if (!chat[i].is_user) {
            testMessage = chat[i].mes;
            break;
        }
    }
    
    if (!testMessage) {
        toastr.warning('没有找到可用于测试的AI消息', '聊天回复检查器');
        return '';
    }
    
    const lastMessage = chat[chat.length - 1];
    
    if (lastMessage.is_user) {
        toastr.warning('最后一条消息是用户消息，无法测试', '聊天回复检查器');
        return '';
    }
    
    // 临时修改最后一条消息来模拟重复
    const originalMessage = lastMessage.mes;
    lastMessage.mes = testMessage + '\n\n' + testMessage;
    
    toastr.info('正在使用API测试检测功能...', '聊天回复检查器');
    
    // 获取上下文消息
    const contextCount = settings.contextMessages || 2;
    const startIndex = Math.max(0, chat.length - 1 - contextCount);
    const previousMessages = chat.slice(startIndex, chat.length - 1);
    
    // 使用API检查
    const fixedMessage = await checkAndFixWithAPI(lastMessage, previousMessages);
    
    // 恢复原始消息
    lastMessage.mes = originalMessage;
    
    if (fixedMessage && fixedMessage !== (testMessage + '\n\n' + testMessage)) {
        toastr.success('测试成功！API检测到重复内容并提供了修复建议', '聊天回复检查器');
    } else {
        toastr.warning('测试结果：API未检测到问题，请检查API配置或系统提示词', '聊天回复检查器');
    }
    
    return '';
}

// jQuery准备就绪
jQuery(async () => {
    // 加载设置
    await loadSettings();
    
    // 添加设置面板HTML
    const settingsHtml = await $.get(`/${extensionFolderPath}/settings.html`);
    $('#extensions_settings2').append(settingsHtml);
    
    // 绑定设置事件
    $('#chat_reply_checker_enabled').on('change', function() {
        extension_settings[extensionName].enabled = $(this).prop('checked');
        saveSettings();
    });
    
    $('#chat_reply_checker_api_url').on('input', function() {
        extension_settings[extensionName].apiUrl = String($(this).val());
        saveSettings();
    });
    
    $('#chat_reply_checker_api_key').on('input', function() {
        extension_settings[extensionName].apiKey = String($(this).val());
        saveSettings();
    });
    
    $('#chat_reply_checker_model').on('input', function() {
        extension_settings[extensionName].model = String($(this).val());
        saveSettings();
    });
    
    $('#chat_reply_checker_max_tokens').on('input', function() {
        extension_settings[extensionName].maxTokens = parseInt(String($(this).val()));
        $('#chat_reply_checker_max_tokens_value').text(extension_settings[extensionName].maxTokens);
        saveSettings();
    });
    
    $('#chat_reply_checker_temperature').on('input', function() {
        extension_settings[extensionName].temperature = parseFloat(String($(this).val()));
        $('#chat_reply_checker_temperature_value').text(extension_settings[extensionName].temperature);
        saveSettings();
    });
    
    $('#chat_reply_checker_context_messages').on('input', function() {
        const newValue = parseInt(String($(this).val()));
        extension_settings[extensionName].contextMessages = newValue;
        $('#chat_reply_checker_context_messages_value').text(newValue);
        console.log('[聊天回复检查器] 上下文消息数量已更新为:', newValue);
        saveSettings();
    });
    
    $('#chat_reply_checker_system_prompt').on('input', function() {
        extension_settings[extensionName].systemPrompt = $(this).val();
        saveSettings();
    });
    
    // 绑定测试按钮
    $('#chat_reply_checker_test').on('click', checkCommand);
    $('#chat_reply_checker_fix_now').on('click', fixCommand);
    
    // 监听消息生成完成但未渲染的事件
    eventSource.on(event_types.MESSAGE_RECEIVED, onMessageReceived);
    eventSource.on(event_types.IMPERSONATE_READY, onMessageReceived);
    
    // 注册斜杠命令
    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
        name: 'check-reply',
        callback: checkCommand,
        helpString: '检查最新的AI回复是否有问题',
    }));
    
    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
        name: 'fix-reply',
        callback: fixCommand,
        helpString: '修复最新的AI回复中的问题',
    }));
    
    SlashCommandParser.addCommandObject(SlashCommand.fromProps({
        name: 'test-reply-checker',
        callback: testReplyChecker,
        helpString: '测试聊天回复检查器功能',
    }));
    
    // 更新UI
    updateUI();
    
    console.log('聊天回复检查器插件已加载');
}); 